package com.qianbei.common.utilis.img;

import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.os.Environment;
import android.util.DisplayMetrics;
import android.util.Log;

import com.qianbei.common.base.BaseApplication;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class ImageTools {

	// public static Bitmap toRoundCorner(Bitmap bitmap, int pixels) {
	//
	// if (bitmap != null) {
	// Bitmap output = Bitmap.createBitmap(bitmap.getWidth(),
	// bitmap.getHeight(), Config.ARGB_8888);
	// Canvas canvas = new Canvas(output);
	//
	// final int color = 0xff424242;
	// final Paint paint = new Paint();
	// final Rect rect = new Rect(0, 0, bitmap.getWidth(),
	// bitmap.getHeight());
	// final RectF rectF = new RectF(rect);
	// final float roundPx = pixels;
	// paint.setAntiAlias(true);
	// canvas.drawARGB(0, 0, 0, 0);
	// paint.setColor(color);
	// canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
	// paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
	// canvas.drawBitmap(bitmap, rect, rect, paint);
	// return output;
	// } else {
	// return null;
	// }
	//
	// }
	//
	// public static LayoutParams setHeight(View v, int viewWidth, int picWidth,
	// int picHeight) {
	// LayoutParams p = v.getLayoutParams();
	// // p.width = viewWidth;
	// if (picHeight != 0) {
	// p.height = Math.min((int) (picHeight * viewWidth / picWidth),
	// (int) (ImageTools.getDisHight() * 1.5f));
	// } else {
	// p.height = 0;
	// }
	// if (p.height > picHeight) {
	// p.height = picHeight;
	// }
	// return p;
	// }
	//
	/**
	 * 根据路径加载一个指定大小范围的图片
	 * 
	 * @param path
	 *            图片路径
	 * @return 返回Bitmap
	 */
	public static Bitmap bitmapFromPath(String path, int maxWidth, int maxHeight) {

		Bitmap bit;
		BitmapFactory.Options bmpFactoryOptions = new BitmapFactory.Options();
		// if(maxWidth != -1){
		bmpFactoryOptions.inJustDecodeBounds = true;
		bit = BitmapFactory.decodeFile(path, bmpFactoryOptions);
		int heightRadio = (int) Math.ceil(bmpFactoryOptions.outHeight
				/ (float) maxHeight);
		int widthtRadio = (int) Math.ceil(bmpFactoryOptions.outHeight
				/ (float) maxWidth);
		if (heightRadio > 1 && widthtRadio > 1) {
			if (heightRadio > widthtRadio) {
				bmpFactoryOptions.inSampleSize = heightRadio;
			} else {
				bmpFactoryOptions.inSampleSize = widthtRadio;
			}
		}
		bmpFactoryOptions.inJustDecodeBounds = false;
		bmpFactoryOptions.inPreferredConfig = Config.RGB_565;
		bit = BitmapFactory.decodeFile(path, bmpFactoryOptions);
		// }
		// else{
		// bmpFactoryOptions.inJustDecodeBounds = true;
		// bit = BitmapFactory.decodeFile(path, bmpFactoryOptions);
		// int heightRadio = (int) Math.ceil(bmpFactoryOptions.outHeight
		// / (float) FFConfig.SysInfo.DISPLAY_HEIGHT);
		// int widthtRadio = (int) Math.ceil(bmpFactoryOptions.outHeight
		// / (float) FFConfig.SysInfo.DISPLAY_WIDTH);
		// if (heightRadio > 1 && widthtRadio > 1)
		// {
		// if (heightRadio > widthtRadio)
		// {
		// bmpFactoryOptions.inSampleSize = heightRadio;
		// } else
		// {
		// bmpFactoryOptions.inSampleSize = widthtRadio;
		// }
		// }
		// bmpFactoryOptions.inJustDecodeBounds = false;
		// bmpFactoryOptions.inPreferredConfig = Config.RGB_565;
		// bit = BitmapFactory.decodeFile(path, bmpFactoryOptions);
		// }
		return bit;
	}

	/**
	 * 通过路径获取图片 bitmap 对象
	 * 
	 * @param path
	 * @return
	 */
	private static Bitmap getBitmapFromPaths(String path) {
		Bitmap bit;
		BitmapFactory.Options bmpFactoryOptions = new BitmapFactory.Options();
		// if(maxWidth != -1){
		bmpFactoryOptions.inJustDecodeBounds = false;
		bit = BitmapFactory.decodeFile(path, bmpFactoryOptions);
		return bit;
	}

	/**
	 * 
	 * @param map
	 *            图片源
	 * @param width
	 *            图片期望宽度
	 * @return 算出期望和实际的比例
	 */
	private static float getBi(Bitmap map, int width) {
		float bi;
		float widthTrue;
		if (map != null) {
			widthTrue = map.getWidth();
			bi =widthTrue/width;
		} else {
			bi =1;
		}

		return bi ;
	}

	public static Bitmap getBitmap(String frombitMa) {

		Bitmap bitMap = getBitmapFromPaths(frombitMa);

		float bi = getBi(bitMap, 50);
		int width = bitMap.getWidth();
		int height = bitMap.getHeight();
		int newWidth = (int) (width / bi);
		int newHeight = (int) (height / bi);

		// 设置想要的大小
		// 计算缩放比例
		// 取得想要缩放的matrix参数
		Matrix matrix = new Matrix();
		matrix.postScale(newWidth, newHeight);
		// 得到新的图片
		bitMap = Bitmap.createBitmap(bitMap, 0, 0, newWidth, newHeight, matrix,
				true);
		return bitMap;
	}

	public static Bitmap bitmapFromPath(Bitmap frombitMa, float bi) {
		Bitmap bitMap = frombitMa;
		int width = bitMap.getWidth();
		int height = bitMap.getHeight();
		int newWidth = (int) (bi * BaseApplication.screenWidth);
		int newHeight = (newWidth * height / width);

		// 设置想要的大小
		// 计算缩放比例
		// 取得想要缩放的matrix参数
		Matrix matrix = new Matrix();
		matrix.postScale(newWidth, newHeight);
		// 得到新的图片
		bitMap = Bitmap.createBitmap(bitMap, 0, 0, newWidth, newHeight, matrix,
				true);
		return bitMap;
	}

	//
	private static float density = 0;

	//
	/**
	 * 获取像素密度 （1dp的像素数）
	 * 
	 * @return
	 */
	public static float getDensity() {
		if (density != 0) {
			return density;
		}
		Resources resources = BaseApplication.mApplication.getResources();
		DisplayMetrics dm = resources.getDisplayMetrics();
		return dm.density;
	}

	//
	private static int display_width = 0;
	private static int display_height = 0;

	/**
	 * 获取屏幕高度
	 * 
	 * @param activity
	 * @return
	 */
	public static int getDisHight() {
		if (display_height != 0) {
			return display_height;
		}
		Resources resources = BaseApplication.mApplication.getResources();
		DisplayMetrics dm = resources.getDisplayMetrics();
		display_width = dm.widthPixels;
		display_height = dm.heightPixels;
		return display_height;
	}

	//
	// /**
	// * 获取屏幕宽度
	// *
	// * @param activity
	// * @return
	// */
	public static int getDisWidth() {
		if (display_width != 0) {
			return display_width;
		}
		Resources resources = BaseApplication.mApplication.getResources();
		DisplayMetrics dm = resources.getDisplayMetrics();
		display_width = dm.widthPixels;
		display_height = dm.heightPixels;
		return display_width;
	}

	//
	// // 获取图片文件的长和宽 arys[0]=width,arys[1]=height
	// public static int[] getImageFileBound(File image) {
	// if (image == null || !image.exists()) {
	// throw new IllegalArgumentException(
	// "argument 'image' must be a exists file");
	// }
	//
	// BitmapFactory.Options options = new BitmapFactory.Options();
	// try {
	// options.inJustDecodeBounds = true;
	// BitmapFactory.decodeFile(image.getAbsolutePath(), options);
	// } catch (OutOfMemoryError e) {
	// e.printStackTrace();
	// }
	// return new int[] { options.outWidth, options.outHeight };
	// }
	//
	/*
	 * 图片按比例大小压缩方法（根据路径获取图片并压缩）：
	 */
	public static Bitmap getimage(String srcPath) {
		BitmapFactory.Options newOpts = new BitmapFactory.Options();
		// 开始读入图片，此时把options.inJustDecodeBounds 设回true了
		newOpts.inJustDecodeBounds = true;
		Bitmap bitmap = BitmapFactory.decodeFile(srcPath, newOpts);// 此时返回bm为空

		newOpts.inJustDecodeBounds = false;
		int w = newOpts.outWidth;
		int h = newOpts.outHeight;
		// 现在主流手机比较多是800*480分辨率，所以高和宽我们设置为
		float hh = 800f;// 这里设置高度为800f
		float ww = 480f;// 这里设置宽度为480f
		// 缩放比。由于是固定比例缩放，只用高或者宽其中一个数据进行计算即可
		int be = 1;// be=1表示不缩放
		if (w > h && w > ww) {// 如果宽度大的话根据宽度固定大小缩放
			be = (int) (newOpts.outWidth / ww);
		} else if (w < h && h > hh) {// 如果高度高的话根据宽度固定大小缩放
			be = (int) (newOpts.outHeight / hh);
		}
		if (be <= 0)
			be = 1;
		newOpts.inSampleSize = be;// 设置缩放比例
		// 重新读入图片，注意此时已经把options.inJustDecodeBounds 设回false了
		bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
		return bitmap;
		// return compressImage(bitmap);// 压缩好比例大小后再进行质量压缩
	}

	//
	// /*
	// * 第一：我们先看下质量压缩方法：
	// */
	//
	// private static Bitmap compressImage(Bitmap image) {
	//
	// ByteArrayOutputStream baos = new ByteArrayOutputStream();
	// image.compress(Bitmap.CompressFormat.JPEG, 100, baos);//
	// 质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
	// int options = 100;
	// while (baos.toByteArray().length / 1024 > 100) { //
	// 循环判断如果压缩后图片是否大于100kb,大于继续压缩
	// baos.reset();// 重置baos即清空baos
	// image.compress(Bitmap.CompressFormat.JPEG, options, baos);//
	// 这里压缩options%，把压缩后的数据存放到baos中
	// options -= 10;// 每次都减少10
	// }
	// ByteArrayInputStream isBm = new
	// ByteArrayInputStream(baos.toByteArray());//
	// 把压缩后的数据baos存放到ByteArrayInputStream中
	// Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);//
	// 把ByteArrayInputStream数据生成图片
	// return bitmap;
	// }
	//
	// /*
	// *
	// * 第三：图片按比例大小压缩方法（根据Bitmap图片压缩）：
	// */
	//
	// private Bitmap comp(Bitmap image) {
	//
	// ByteArrayOutputStream baos = new ByteArrayOutputStream();
	// image.compress(Bitmap.CompressFormat.JPEG, 100, baos);
	// if (baos.toByteArray().length / 1024 > 1024) {//
	// 判断如果图片大于1M,进行压缩避免在生成图片（BitmapFactory.decodeStream）时溢出
	// baos.reset();// 重置baos即清空baos
	// image.compress(Bitmap.CompressFormat.JPEG, 50, baos);//
	// 这里压缩50%，把压缩后的数据存放到baos中
	// }
	// ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());
	// BitmapFactory.Options newOpts = new BitmapFactory.Options();
	// // 开始读入图片，此时把options.inJustDecodeBounds 设回true了
	// newOpts.inJustDecodeBounds = true;
	// Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, newOpts);
	// newOpts.inJustDecodeBounds = false;
	// int w = newOpts.outWidth;
	// int h = newOpts.outHeight;
	// // 现在主流手机比较多是800*480分辨率，所以高和宽我们设置为
	// float hh = 800f;// 这里设置高度为800f
	// float ww = 480f;// 这里设置宽度为480f
	// // 缩放比。由于是固定比例缩放，只用高或者宽其中一个数据进行计算即可
	// int be = 1;// be=1表示不缩放
	// if (w > h && w > ww) {// 如果宽度大的话根据宽度固定大小缩放
	// be = (int) (newOpts.outWidth / ww);
	// } else if (w < h && h > hh) {// 如果高度高的话根据宽度固定大小缩放
	// be = (int) (newOpts.outHeight / hh);
	// }
	// if (be <= 0)
	// be = 1;
	// newOpts.inSampleSize = be;// 设置缩放比例
	// // 重新读入图片，注意此时已经把options.inJustDecodeBounds 设回false了
	// isBm = new ByteArrayInputStream(baos.toByteArray());
	// bitmap = BitmapFactory.decodeStream(isBm, null, newOpts);
	// return compressImage(bitmap);// 压缩好比例大小后再进行质量压缩
	// }
	//
	/*
	 * bitmap 转换为文件
	 */
	public static boolean saveBitmap2file(Bitmap bmp, String filename) {
		CompressFormat format = Bitmap.CompressFormat.JPEG;
		int quality = 100;
		OutputStream stream = null;
		try {
			stream = new FileOutputStream(CanmlTools.AppConfig.APPFILEPASS
					+ filename.replaceAll(":", "_") + ".jpg");
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return bmp.compress(format, quality, stream);
	}

    /**
     * 1、如果图片比较大，而且在sd目录中，就先用getimage()的方法压缩一下图片，然后再用该方法。
     * 2、压缩图片并返回压缩后的图片的path，先改变图片的质量，再按比例改变图片的宽高。
     * @param context
     * @param bmp
     * @return
     */
    public static String getCompressImagePath(Context context, Bitmap bmp) {
        
        if (bmp != null){
            return null;
        }
        
        int maxFileSize = 100 * 1024;

        int width = bmp.getWidth();
        int height = bmp.getHeight();

        String filePath = getSaveFilePath(context);
        File file = new File(filePath);

        if (!file.exists()) {
            if (!file.mkdirs()) return null;
        }

        try {
            int quality = 100;
            while (true) {
                String temp_file = file.getAbsolutePath() + "/" + createRandFileName();
                File f = new File(temp_file);
                FileOutputStream fos =
                        openFileOutput(f.getName(), Context.MODE_WORLD_WRITEABLE
                                | Context.MODE_WORLD_READABLE, f);
                bmp.compress(Bitmap.CompressFormat.JPEG, quality, fos);

                fos.flush();

                if (f.length() > maxFileSize) {

                    f.delete();

                    if (quality < 30) {
                        width = (int) (width * 0.8);
                        height = (int) (height * 0.8);
                        bmp = Bitmap.createScaledBitmap(bmp, width, height, false);
                        quality = 80;
                        continue;
                    }
                    quality = (int) (quality * 0.8);
                } else {
                    filePath = f.toString();
                    break;
                }
            }
        } catch (FileNotFoundException e) {
            return null;
        } catch (IOException e) {
            return null;
        }

        return filePath;
    }

    /**
     * 获取压缩文件的保存路径
     * 
     * @param context
     * @return
     */
    public static String getSaveFilePath(Context context) {

        if (!Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            return null;
        }

        String saveDir = Environment.getExternalStorageDirectory().getAbsolutePath() + "/qianbei/img";

        File file = new File(saveDir);
        if (!file.exists()) {
            if (!file.mkdirs()) return null;
        }

        return saveDir;
    }

    /**
     * 创建随机文件名
     * 
     * @return
     */
    public static String createRandFileName() {
        long randomNumber = Math.round(Math.random() * 8999 + 1000);
        String fileName = "em_" + System.currentTimeMillis() + "_" + randomNumber + ".jpg";
        return fileName;
    }

    /**
     * 创建文件输出流
     * 
     * @param name
     * @param mode
     * @param f
     * @return
     * @throws FileNotFoundException
     */
    public static FileOutputStream openFileOutput(String name, int mode, File f)
            throws FileNotFoundException {
        final boolean append = (mode & Context.MODE_APPEND) != 0;
        File parent = f.getParentFile();
        parent.mkdir();

        FileOutputStream fos = new FileOutputStream(f, append);
        return fos;
    }

}
